// Copyright (c) 2022. Eritque arcus and contributors.
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or any later version(in your opinion).
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
//

#pragma once

#include <algorithm>     // transform
#include <array>         // array
#include <forward_list>  // forward_list
#include <iterator>      // inserter, front_inserter, end
#include <map>           // map
#include <string>        // string
#include <tuple>         // tuple, make_tuple
#include <type_traits>   // is_arithmetic, is_same, is_enum, underlying_type, is_convertible
#include <unordered_map> // unordered_map
#include <utility>       // pair, declval
#include <valarray>      // valarray

#include <nlohmann/detail/exceptions.hpp>
#include <nlohmann/detail/macro_scope.hpp>
#include <nlohmann/detail/meta/cpp_future.hpp>
#include <nlohmann/detail/meta/identity_tag.hpp>
#include <nlohmann/detail/meta/std_fs.hpp>
#include <nlohmann/detail/meta/type_traits.hpp>
#include <nlohmann/detail/string_concat.hpp>
#include <nlohmann/detail/value_t.hpp>

NLOHMANN_JSON_NAMESPACE_BEGIN
namespace detail {

    template<typename BasicJsonType>
    inline void from_json(const BasicJsonType &j, typename std::nullptr_t &n) {
        if (JSON_HEDLEY_UNLIKELY(!j.is_null())) {
            JSON_THROW(type_error::create(302, concat("type must be null, but is ", j.type_name()), &j));
        }
        n = nullptr;
    }

    // overloads for basic_json template parameters
    template<typename BasicJsonType, typename ArithmeticType,
             enable_if_t<std::is_arithmetic<ArithmeticType>::value &&
                                 !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
                         int> = 0>
    void get_arithmetic_value(const BasicJsonType &j, ArithmeticType &val) {
        switch (static_cast<value_t>(j)) {
            case value_t::number_unsigned: {
                val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t *>());
                break;
            }
            case value_t::number_integer: {
                val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t *>());
                break;
            }
            case value_t::number_float: {
                val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t *>());
                break;
            }

            case value_t::null:
            case value_t::object:
            case value_t::array:
            case value_t::string:
            case value_t::boolean:
            case value_t::binary:
            case value_t::discarded:
            default:
                JSON_THROW(type_error::create(302, concat("type must be number, but is ", j.type_name()), &j));
        }
    }

    template<typename BasicJsonType>
    inline void from_json(const BasicJsonType &j, typename BasicJsonType::boolean_t &b) {
        if (JSON_HEDLEY_UNLIKELY(!j.is_boolean())) {
            JSON_THROW(type_error::create(302, concat("type must be boolean, but is ", j.type_name()), &j));
        }
        b = *j.template get_ptr<const typename BasicJsonType::boolean_t *>();
    }

    template<typename BasicJsonType>
    inline void from_json(const BasicJsonType &j, typename BasicJsonType::string_t &s) {
        if (JSON_HEDLEY_UNLIKELY(!j.is_string())) {
            JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j));
        }
        s = *j.template get_ptr<const typename BasicJsonType::string_t *>();
    }

    template<
            typename BasicJsonType, typename StringType,
            enable_if_t<
                    std::is_assignable<StringType &, const typename BasicJsonType::string_t>::value && is_detected_exact<typename BasicJsonType::string_t::value_type, value_type_t, StringType>::value && !std::is_same<typename BasicJsonType::string_t, StringType>::value && !is_json_ref<StringType>::value, int> = 0>
    inline void from_json(const BasicJsonType &j, StringType &s) {
        if (JSON_HEDLEY_UNLIKELY(!j.is_string())) {
            JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j));
        }

        s = *j.template get_ptr<const typename BasicJsonType::string_t *>();
    }

    template<typename BasicJsonType>
    inline void from_json(const BasicJsonType &j, typename BasicJsonType::number_float_t &val) {
        get_arithmetic_value(j, val);
    }

    template<typename BasicJsonType>
    inline void from_json(const BasicJsonType &j, typename BasicJsonType::number_unsigned_t &val) {
        get_arithmetic_value(j, val);
    }

    template<typename BasicJsonType>
    inline void from_json(const BasicJsonType &j, typename BasicJsonType::number_integer_t &val) {
        get_arithmetic_value(j, val);
    }

#if !JSON_DISABLE_ENUM_SERIALIZATION
    template<typename BasicJsonType, typename EnumType,
             enable_if_t<std::is_enum<EnumType>::value, int> = 0>
    inline void from_json(const BasicJsonType &j, EnumType &e) {
        typename std::underlying_type<EnumType>::type val;
        get_arithmetic_value(j, val);
        e = static_cast<EnumType>(val);
    }
#endif // JSON_DISABLE_ENUM_SERIALIZATION

    // forward_list doesn't have an insert method
    template<typename BasicJsonType, typename T, typename Allocator,
             enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
    inline void from_json(const BasicJsonType &j, std::forward_list<T, Allocator> &l) {
        if (JSON_HEDLEY_UNLIKELY(!j.is_array())) {
            JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
        }
        l.clear();
        std::transform(j.rbegin(), j.rend(),
                       std::front_inserter(l), [](const BasicJsonType &i) {
                           return i.template get<T>();
                       });
    }

    // valarray doesn't have an insert method
    template<typename BasicJsonType, typename T,
             enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
    inline void from_json(const BasicJsonType &j, std::valarray<T> &l) {
        if (JSON_HEDLEY_UNLIKELY(!j.is_array())) {
            JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
        }
        l.resize(j.size());
        std::transform(j.begin(), j.end(), std::begin(l),
                       [](const BasicJsonType &elem) {
                           return elem.template get<T>();
                       });
    }

    template<typename BasicJsonType, typename T, std::size_t N>
    auto from_json(const BasicJsonType &j, T (&arr)[N]) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
            -> decltype(j.template get<T>(), void()) {
        for (std::size_t i = 0; i < N; ++i) {
            arr[i] = j.at(i).template get<T>();
        }
    }

    template<typename BasicJsonType>
    inline void from_json_array_impl(const BasicJsonType &j, typename BasicJsonType::array_t &arr, priority_tag<3> /*unused*/) {
        arr = *j.template get_ptr<const typename BasicJsonType::array_t *>();
    }

    template<typename BasicJsonType, typename T, std::size_t N>
    auto from_json_array_impl(const BasicJsonType &j, std::array<T, N> &arr,
                              priority_tag<2> /*unused*/)
            -> decltype(j.template get<T>(), void()) {
        for (std::size_t i = 0; i < N; ++i) {
            arr[i] = j.at(i).template get<T>();
        }
    }

    template<typename BasicJsonType, typename ConstructibleArrayType,
             enable_if_t<
                     std::is_assignable<ConstructibleArrayType &, ConstructibleArrayType>::value,
                     int> = 0>
    auto from_json_array_impl(const BasicJsonType &j, ConstructibleArrayType &arr, priority_tag<1> /*unused*/)
            -> decltype(arr.reserve(std::declval<typename ConstructibleArrayType::size_type>()),
                        j.template get<typename ConstructibleArrayType::value_type>(),
                        void()) {
        using std::end;

        ConstructibleArrayType ret;
        ret.reserve(j.size());
        std::transform(j.begin(), j.end(),
                       std::inserter(ret, end(ret)), [](const BasicJsonType &i) {
                           // get<BasicJsonType>() returns *this, this won't call a from_json
                           // method when value_type is BasicJsonType
                           return i.template get<typename ConstructibleArrayType::value_type>();
                       });
        arr = std::move(ret);
    }

    template<typename BasicJsonType, typename ConstructibleArrayType,
             enable_if_t<
                     std::is_assignable<ConstructibleArrayType &, ConstructibleArrayType>::value,
                     int> = 0>
    inline void from_json_array_impl(const BasicJsonType &j, ConstructibleArrayType &arr,
                                     priority_tag<0> /*unused*/) {
        using std::end;

        ConstructibleArrayType ret;
        std::transform(
                j.begin(), j.end(), std::inserter(ret, end(ret)),
                [](const BasicJsonType &i) {
                    // get<BasicJsonType>() returns *this, this won't call a from_json
                    // method when value_type is BasicJsonType
                    return i.template get<typename ConstructibleArrayType::value_type>();
                });
        arr = std::move(ret);
    }

    template<typename BasicJsonType, typename ConstructibleArrayType,
             enable_if_t<
                     is_constructible_array_type<BasicJsonType, ConstructibleArrayType>::value &&
                             !is_constructible_object_type<BasicJsonType, ConstructibleArrayType>::value &&
                             !is_constructible_string_type<BasicJsonType, ConstructibleArrayType>::value &&
                             !std::is_same<ConstructibleArrayType, typename BasicJsonType::binary_t>::value &&
                             !is_basic_json<ConstructibleArrayType>::value,
                     int> = 0>
    auto from_json(const BasicJsonType &j, ConstructibleArrayType &arr)
            -> decltype(from_json_array_impl(j, arr, priority_tag<3>{}),
                        j.template get<typename ConstructibleArrayType::value_type>(),
                        void()) {
        if (JSON_HEDLEY_UNLIKELY(!j.is_array())) {
            JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
        }

        from_json_array_impl(j, arr, priority_tag<3>{});
    }

    template<typename BasicJsonType, typename T, std::size_t... Idx>
    std::array<T, sizeof...(Idx)> from_json_inplace_array_impl(BasicJsonType &&j,
                                                               identity_tag<std::array<T, sizeof...(Idx)>> /*unused*/, index_sequence<Idx...> /*unused*/) {
        return {{std::forward<BasicJsonType>(j).at(Idx).template get<T>()...}};
    }

    template<typename BasicJsonType, typename T, std::size_t N>
    auto from_json(BasicJsonType &&j, identity_tag<std::array<T, N>> tag)
            -> decltype(from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N>{})) {
        if (JSON_HEDLEY_UNLIKELY(!j.is_array())) {
            JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
        }

        return from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N>{});
    }

    template<typename BasicJsonType>
    inline void from_json(const BasicJsonType &j, typename BasicJsonType::binary_t &bin) {
        if (JSON_HEDLEY_UNLIKELY(!j.is_binary())) {
            JSON_THROW(type_error::create(302, concat("type must be binary, but is ", j.type_name()), &j));
        }

        bin = *j.template get_ptr<const typename BasicJsonType::binary_t *>();
    }

    template<typename BasicJsonType, typename ConstructibleObjectType,
             enable_if_t<is_constructible_object_type<BasicJsonType, ConstructibleObjectType>::value, int> = 0>
    inline void from_json(const BasicJsonType &j, ConstructibleObjectType &obj) {
        if (JSON_HEDLEY_UNLIKELY(!j.is_object())) {
            JSON_THROW(type_error::create(302, concat("type must be object, but is ", j.type_name()), &j));
        }

        ConstructibleObjectType ret;
        const auto *inner_object = j.template get_ptr<const typename BasicJsonType::object_t *>();
        using value_type = typename ConstructibleObjectType::value_type;
        std::transform(
                inner_object->begin(), inner_object->end(),
                std::inserter(ret, ret.begin()),
                [](typename BasicJsonType::object_t::value_type const &p) {
                    return value_type(p.first, p.second.template get<typename ConstructibleObjectType::mapped_type>());
                });
        obj = std::move(ret);
    }

    // overload for arithmetic types, not chosen for basic_json template arguments
    // (BooleanType, etc..); note: Is it really necessary to provide explicit
    // overloads for boolean_t etc. in case of a custom BooleanType which is not
    // an arithmetic type?
    template<typename BasicJsonType, typename ArithmeticType,
             enable_if_t<
                     std::is_arithmetic<ArithmeticType>::value &&
                             !std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value &&
                             !std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value &&
                             !std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value &&
                             !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
                     int> = 0>
    inline void from_json(const BasicJsonType &j, ArithmeticType &val) {
        switch (static_cast<value_t>(j)) {
            case value_t::number_unsigned: {
                val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t *>());
                break;
            }
            case value_t::number_integer: {
                val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t *>());
                break;
            }
            case value_t::number_float: {
                val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t *>());
                break;
            }
            case value_t::boolean: {
                val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::boolean_t *>());
                break;
            }

            case value_t::null:
            case value_t::object:
            case value_t::array:
            case value_t::string:
            case value_t::binary:
            case value_t::discarded:
            default:
                JSON_THROW(type_error::create(302, concat("type must be number, but is ", j.type_name()), &j));
        }
    }

    template<typename BasicJsonType, typename... Args, std::size_t... Idx>
    std::tuple<Args...> from_json_tuple_impl_base(BasicJsonType &&j, index_sequence<Idx...> /*unused*/) {
        return std::make_tuple(std::forward<BasicJsonType>(j).at(Idx).template get<Args>()...);
    }

    template<typename BasicJsonType, class A1, class A2>
    std::pair<A1, A2> from_json_tuple_impl(BasicJsonType &&j, identity_tag<std::pair<A1, A2>> /*unused*/, priority_tag<0> /*unused*/) {
        return {std::forward<BasicJsonType>(j).at(0).template get<A1>(),
                std::forward<BasicJsonType>(j).at(1).template get<A2>()};
    }

    template<typename BasicJsonType, typename A1, typename A2>
    inline void from_json_tuple_impl(BasicJsonType &&j, std::pair<A1, A2> &p, priority_tag<1> /*unused*/) {
        p = from_json_tuple_impl(std::forward<BasicJsonType>(j), identity_tag<std::pair<A1, A2>>{}, priority_tag<0>{});
    }

    template<typename BasicJsonType, typename... Args>
    std::tuple<Args...> from_json_tuple_impl(BasicJsonType &&j, identity_tag<std::tuple<Args...>> /*unused*/, priority_tag<2> /*unused*/) {
        return from_json_tuple_impl_base<BasicJsonType, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...>{});
    }

    template<typename BasicJsonType, typename... Args>
    inline void from_json_tuple_impl(BasicJsonType &&j, std::tuple<Args...> &t, priority_tag<3> /*unused*/) {
        t = from_json_tuple_impl_base<BasicJsonType, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...>{});
    }

    template<typename BasicJsonType, typename TupleRelated>
    auto from_json(BasicJsonType &&j, TupleRelated &&t)
            -> decltype(from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3>{})) {
        if (JSON_HEDLEY_UNLIKELY(!j.is_array())) {
            JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
        }

        return from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3>{});
    }

    template<typename BasicJsonType, typename Key, typename Value, typename Compare, typename Allocator,
             typename = enable_if_t<!std::is_constructible<
                     typename BasicJsonType::string_t, Key>::value>>
    inline void from_json(const BasicJsonType &j, std::map<Key, Value, Compare, Allocator> &m) {
        if (JSON_HEDLEY_UNLIKELY(!j.is_array())) {
            JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
        }
        m.clear();
        for (const auto &p: j) {
            if (JSON_HEDLEY_UNLIKELY(!p.is_array())) {
                JSON_THROW(type_error::create(302, concat("type must be array, but is ", p.type_name()), &j));
            }
            m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
        }
    }

    template<typename BasicJsonType, typename Key, typename Value, typename Hash, typename KeyEqual, typename Allocator,
             typename = enable_if_t<!std::is_constructible<
                     typename BasicJsonType::string_t, Key>::value>>
    inline void from_json(const BasicJsonType &j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator> &m) {
        if (JSON_HEDLEY_UNLIKELY(!j.is_array())) {
            JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
        }
        m.clear();
        for (const auto &p: j) {
            if (JSON_HEDLEY_UNLIKELY(!p.is_array())) {
                JSON_THROW(type_error::create(302, concat("type must be array, but is ", p.type_name()), &j));
            }
            m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
        }
    }

#if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM
    template<typename BasicJsonType>
    inline void from_json(const BasicJsonType &j, std_fs::path &p) {
        if (JSON_HEDLEY_UNLIKELY(!j.is_string())) {
            JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j));
        }
        p = *j.template get_ptr<const typename BasicJsonType::string_t *>();
    }
#endif

    struct from_json_fn {
        template<typename BasicJsonType, typename T>
        auto operator()(const BasicJsonType &j, T &&val) const
                noexcept(noexcept(from_json(j, std::forward<T>(val))))
                        -> decltype(from_json(j, std::forward<T>(val))) {
            return from_json(j, std::forward<T>(val));
        }
    };

} // namespace detail

#ifndef JSON_HAS_CPP_17
/// namespace to hold default `from_json` function
/// to see why this is required:
/// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
namespace // NOLINT(cert-dcl59-cpp,fuchsia-header-anon-namespaces,google-build-namespaces)
{
#endif
    JSON_INLINE_VARIABLE constexpr const auto &from_json = // NOLINT(misc-definitions-in-headers)
            detail::static_const<detail::from_json_fn>::value;
#ifndef JSON_HAS_CPP_17
} // namespace
#endif

NLOHMANN_JSON_NAMESPACE_END
